using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.InteropServices;

using ILRuntime.CLR.TypeSystem;
using ILRuntime.CLR.Method;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Intepreter;
using ILRuntime.Runtime.Stack;
using ILRuntime.Reflection;
using ILRuntime.CLR.Utils;
using System.Linq;

namespace ILRuntime.Runtime.Generated
{
    unsafe class huqiang_Core_UIData_UIElementData_Binding
    {
        public static void Register(ILRuntime.Runtime.Enviorment.AppDomain app)
        {
            BindingFlags flag = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
            FieldInfo field;
            Type[] args;
            Type type = typeof(huqiang.Core.UIData.UIElementData);

            field = type.GetField("type", flag);
            app.RegisterCLRFieldGetter(field, get_type_0);
            app.RegisterCLRFieldSetter(field, set_type_0);
            app.RegisterCLRFieldBinding(field, CopyToStack_type_0, AssignFromStack_type_0);
            field = type.GetField("insID", flag);
            app.RegisterCLRFieldGetter(field, get_insID_1);
            app.RegisterCLRFieldSetter(field, set_insID_1);
            app.RegisterCLRFieldBinding(field, CopyToStack_insID_1, AssignFromStack_insID_1);
            field = type.GetField("activeSelf", flag);
            app.RegisterCLRFieldGetter(field, get_activeSelf_2);
            app.RegisterCLRFieldSetter(field, set_activeSelf_2);
            app.RegisterCLRFieldBinding(field, CopyToStack_activeSelf_2, AssignFromStack_activeSelf_2);
            field = type.GetField("name", flag);
            app.RegisterCLRFieldGetter(field, get_name_3);
            app.RegisterCLRFieldSetter(field, set_name_3);
            app.RegisterCLRFieldBinding(field, CopyToStack_name_3, AssignFromStack_name_3);
            field = type.GetField("localScale", flag);
            app.RegisterCLRFieldGetter(field, get_localScale_4);
            app.RegisterCLRFieldSetter(field, set_localScale_4);
            app.RegisterCLRFieldBinding(field, CopyToStack_localScale_4, AssignFromStack_localScale_4);
            field = type.GetField("localPosition", flag);
            app.RegisterCLRFieldGetter(field, get_localPosition_5);
            app.RegisterCLRFieldSetter(field, set_localPosition_5);
            app.RegisterCLRFieldBinding(field, CopyToStack_localPosition_5, AssignFromStack_localPosition_5);
            field = type.GetField("localRotation", flag);
            app.RegisterCLRFieldGetter(field, get_localRotation_6);
            app.RegisterCLRFieldSetter(field, set_localRotation_6);
            app.RegisterCLRFieldBinding(field, CopyToStack_localRotation_6, AssignFromStack_localRotation_6);
            field = type.GetField("m_sizeDelta", flag);
            app.RegisterCLRFieldGetter(field, get_m_sizeDelta_7);
            app.RegisterCLRFieldSetter(field, set_m_sizeDelta_7);
            app.RegisterCLRFieldBinding(field, CopyToStack_m_sizeDelta_7, AssignFromStack_m_sizeDelta_7);
            field = type.GetField("Pivot", flag);
            app.RegisterCLRFieldGetter(field, get_Pivot_8);
            app.RegisterCLRFieldSetter(field, set_Pivot_8);
            app.RegisterCLRFieldBinding(field, CopyToStack_Pivot_8, AssignFromStack_Pivot_8);
            field = type.GetField("scaleType", flag);
            app.RegisterCLRFieldGetter(field, get_scaleType_9);
            app.RegisterCLRFieldSetter(field, set_scaleType_9);
            app.RegisterCLRFieldBinding(field, CopyToStack_scaleType_9, AssignFromStack_scaleType_9);
            field = type.GetField("anchorType", flag);
            app.RegisterCLRFieldGetter(field, get_anchorType_10);
            app.RegisterCLRFieldSetter(field, set_anchorType_10);
            app.RegisterCLRFieldBinding(field, CopyToStack_anchorType_10, AssignFromStack_anchorType_10);
            field = type.GetField("anchorPointType", flag);
            app.RegisterCLRFieldGetter(field, get_anchorPointType_11);
            app.RegisterCLRFieldSetter(field, set_anchorPointType_11);
            app.RegisterCLRFieldBinding(field, CopyToStack_anchorPointType_11, AssignFromStack_anchorPointType_11);
            field = type.GetField("anchorOffset", flag);
            app.RegisterCLRFieldGetter(field, get_anchorOffset_12);
            app.RegisterCLRFieldSetter(field, set_anchorOffset_12);
            app.RegisterCLRFieldBinding(field, CopyToStack_anchorOffset_12, AssignFromStack_anchorOffset_12);
            field = type.GetField("marginType", flag);
            app.RegisterCLRFieldGetter(field, get_marginType_13);
            app.RegisterCLRFieldSetter(field, set_marginType_13);
            app.RegisterCLRFieldBinding(field, CopyToStack_marginType_13, AssignFromStack_marginType_13);
            field = type.GetField("parentType", flag);
            app.RegisterCLRFieldGetter(field, get_parentType_14);
            app.RegisterCLRFieldSetter(field, set_parentType_14);
            app.RegisterCLRFieldBinding(field, CopyToStack_parentType_14, AssignFromStack_parentType_14);
            field = type.GetField("margin", flag);
            app.RegisterCLRFieldGetter(field, get_margin_15);
            app.RegisterCLRFieldSetter(field, set_margin_15);
            app.RegisterCLRFieldBinding(field, CopyToStack_margin_15, AssignFromStack_margin_15);
            field = type.GetField("eventType", flag);
            app.RegisterCLRFieldGetter(field, get_eventType_16);
            app.RegisterCLRFieldSetter(field, set_eventType_16);
            app.RegisterCLRFieldBinding(field, CopyToStack_eventType_16, AssignFromStack_eventType_16);
            field = type.GetField("compositeType", flag);
            app.RegisterCLRFieldGetter(field, get_compositeType_17);
            app.RegisterCLRFieldSetter(field, set_compositeType_17);
            app.RegisterCLRFieldBinding(field, CopyToStack_compositeType_17, AssignFromStack_compositeType_17);
            field = type.GetField("child", flag);
            app.RegisterCLRFieldGetter(field, get_child_18);
            app.RegisterCLRFieldSetter(field, set_child_18);
            app.RegisterCLRFieldBinding(field, CopyToStack_child_18, AssignFromStack_child_18);
            field = type.GetField("eve", flag);
            app.RegisterCLRFieldGetter(field, get_eve_19);
            app.RegisterCLRFieldSetter(field, set_eve_19);
            app.RegisterCLRFieldBinding(field, CopyToStack_eve_19, AssignFromStack_eve_19);
            field = type.GetField("composite", flag);
            app.RegisterCLRFieldGetter(field, get_composite_20);
            app.RegisterCLRFieldSetter(field, set_composite_20);
            app.RegisterCLRFieldBinding(field, CopyToStack_composite_20, AssignFromStack_composite_20);
            field = type.GetField("ex", flag);
            app.RegisterCLRFieldGetter(field, get_ex_21);
            app.RegisterCLRFieldSetter(field, set_ex_21);
            app.RegisterCLRFieldBinding(field, CopyToStack_ex_21, AssignFromStack_ex_21);
            field = type.GetField("Mask", flag);
            app.RegisterCLRFieldGetter(field, get_Mask_22);
            app.RegisterCLRFieldSetter(field, set_Mask_22);
            app.RegisterCLRFieldBinding(field, CopyToStack_Mask_22, AssignFromStack_Mask_22);
            field = type.GetField("Size", flag);
            app.RegisterCLRFieldGetter(field, get_Size_23);
            app.RegisterCLRFieldSetter(field, set_Size_23);
            app.RegisterCLRFieldBinding(field, CopyToStack_Size_23, AssignFromStack_Size_23);
            field = type.GetField("ElementSize", flag);
            app.RegisterCLRFieldGetter(field, get_ElementSize_24);
            app.RegisterCLRFieldSetter(field, set_ElementSize_24);
            app.RegisterCLRFieldBinding(field, CopyToStack_ElementSize_24, AssignFromStack_ElementSize_24);

            app.RegisterCLRMemberwiseClone(type, PerformMemberwiseClone);

            app.RegisterCLRCreateDefaultInstance(type, () => new huqiang.Core.UIData.UIElementData());
            app.RegisterCLRCreateArrayInstance(type, s => new huqiang.Core.UIData.UIElementData[s]);


        }

        static void WriteBackInstance(ILRuntime.Runtime.Enviorment.AppDomain __domain, StackObject* ptr_of_this_method, IList<object> __mStack, ref huqiang.Core.UIData.UIElementData instance_of_this_method)
        {
            ptr_of_this_method = ILIntepreter.GetObjectAndResolveReference(ptr_of_this_method);
            switch(ptr_of_this_method->ObjectType)
            {
                case ObjectTypes.Object:
                    {
                        __mStack[ptr_of_this_method->Value] = instance_of_this_method;
                    }
                    break;
                case ObjectTypes.FieldReference:
                    {
                        var ___obj = __mStack[ptr_of_this_method->Value];
                        if(___obj is ILTypeInstance)
                        {
                            ((ILTypeInstance)___obj)[ptr_of_this_method->ValueLow] = instance_of_this_method;
                        }
                        else
                        {
                            var t = __domain.GetType(___obj.GetType()) as CLRType;
                            t.SetFieldValue(ptr_of_this_method->ValueLow, ref ___obj, instance_of_this_method);
                        }
                    }
                    break;
                case ObjectTypes.StaticFieldReference:
                    {
                        var t = __domain.GetType(ptr_of_this_method->Value);
                        if(t is ILType)
                        {
                            ((ILType)t).StaticInstance[ptr_of_this_method->ValueLow] = instance_of_this_method;
                        }
                        else
                        {
                            ((CLRType)t).SetStaticFieldValue(ptr_of_this_method->ValueLow, instance_of_this_method);
                        }
                    }
                    break;
                 case ObjectTypes.ArrayReference:
                    {
                        var instance_of_arrayReference = __mStack[ptr_of_this_method->Value] as huqiang.Core.UIData.UIElementData[];
                        instance_of_arrayReference[ptr_of_this_method->ValueLow] = instance_of_this_method;
                    }
                    break;
            }
        }


        static object get_type_0(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).type;
        }

        static StackObject* CopyToStack_type_0(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).type;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_type_0(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.type = (System.Int32)v;
            o = ins;
        }

        static StackObject* AssignFromStack_type_0(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @type = ptr_of_this_method->Value;
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.type = @type;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_insID_1(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).insID;
        }

        static StackObject* CopyToStack_insID_1(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).insID;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_insID_1(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.insID = (System.Int32)v;
            o = ins;
        }

        static StackObject* AssignFromStack_insID_1(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @insID = ptr_of_this_method->Value;
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.insID = @insID;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_activeSelf_2(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).activeSelf;
        }

        static StackObject* CopyToStack_activeSelf_2(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).activeSelf;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method ? 1 : 0;
            return __ret + 1;
        }

        static void set_activeSelf_2(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.activeSelf = (System.Boolean)v;
            o = ins;
        }

        static StackObject* AssignFromStack_activeSelf_2(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Boolean @activeSelf = ptr_of_this_method->Value == 1;
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.activeSelf = @activeSelf;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_name_3(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).name;
        }

        static StackObject* CopyToStack_name_3(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).name;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_name_3(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.name = (huqiang.Data.StringPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_name_3(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.StringPoint @name = (huqiang.Data.StringPoint)typeof(huqiang.Data.StringPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.name = @name;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_localScale_4(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).localScale;
        }

        static StackObject* CopyToStack_localScale_4(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).localScale;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_localScale_4(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localScale = (UnityEngine.Vector3)v;
            o = ins;
        }

        static StackObject* AssignFromStack_localScale_4(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector3 @localScale = (UnityEngine.Vector3)typeof(UnityEngine.Vector3).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localScale = @localScale;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_localPosition_5(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).localPosition;
        }

        static StackObject* CopyToStack_localPosition_5(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).localPosition;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_localPosition_5(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localPosition = (UnityEngine.Vector3)v;
            o = ins;
        }

        static StackObject* AssignFromStack_localPosition_5(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector3 @localPosition = (UnityEngine.Vector3)typeof(UnityEngine.Vector3).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localPosition = @localPosition;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_localRotation_6(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).localRotation;
        }

        static StackObject* CopyToStack_localRotation_6(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).localRotation;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_localRotation_6(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localRotation = (UnityEngine.Quaternion)v;
            o = ins;
        }

        static StackObject* AssignFromStack_localRotation_6(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Quaternion @localRotation = (UnityEngine.Quaternion)typeof(UnityEngine.Quaternion).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.localRotation = @localRotation;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_m_sizeDelta_7(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).m_sizeDelta;
        }

        static StackObject* CopyToStack_m_sizeDelta_7(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).m_sizeDelta;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_m_sizeDelta_7(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.m_sizeDelta = (UnityEngine.Vector2)v;
            o = ins;
        }

        static StackObject* AssignFromStack_m_sizeDelta_7(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector2 @m_sizeDelta = (UnityEngine.Vector2)typeof(UnityEngine.Vector2).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.m_sizeDelta = @m_sizeDelta;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_Pivot_8(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).Pivot;
        }

        static StackObject* CopyToStack_Pivot_8(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).Pivot;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_Pivot_8(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.Pivot = (UnityEngine.Vector2)v;
            o = ins;
        }

        static StackObject* AssignFromStack_Pivot_8(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector2 @Pivot = (UnityEngine.Vector2)typeof(UnityEngine.Vector2).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.Pivot = @Pivot;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_scaleType_9(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).scaleType;
        }

        static StackObject* CopyToStack_scaleType_9(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).scaleType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_scaleType_9(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.scaleType = (global::ScaleType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_scaleType_9(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::ScaleType @scaleType = (global::ScaleType)typeof(global::ScaleType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.scaleType = @scaleType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_anchorType_10(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).anchorType;
        }

        static StackObject* CopyToStack_anchorType_10(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).anchorType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_anchorType_10(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorType = (global::AnchorType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_anchorType_10(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::AnchorType @anchorType = (global::AnchorType)typeof(global::AnchorType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorType = @anchorType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_anchorPointType_11(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).anchorPointType;
        }

        static StackObject* CopyToStack_anchorPointType_11(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).anchorPointType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_anchorPointType_11(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorPointType = (global::AnchorPointType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_anchorPointType_11(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::AnchorPointType @anchorPointType = (global::AnchorPointType)typeof(global::AnchorPointType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorPointType = @anchorPointType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_anchorOffset_12(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).anchorOffset;
        }

        static StackObject* CopyToStack_anchorOffset_12(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).anchorOffset;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_anchorOffset_12(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorOffset = (UnityEngine.Vector2)v;
            o = ins;
        }

        static StackObject* AssignFromStack_anchorOffset_12(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            UnityEngine.Vector2 @anchorOffset = (UnityEngine.Vector2)typeof(UnityEngine.Vector2).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.anchorOffset = @anchorOffset;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_marginType_13(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).marginType;
        }

        static StackObject* CopyToStack_marginType_13(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).marginType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_marginType_13(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.marginType = (global::MarginType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_marginType_13(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::MarginType @marginType = (global::MarginType)typeof(global::MarginType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.marginType = @marginType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_parentType_14(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).parentType;
        }

        static StackObject* CopyToStack_parentType_14(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).parentType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_parentType_14(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.parentType = (global::ParentType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_parentType_14(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::ParentType @parentType = (global::ParentType)typeof(global::ParentType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.parentType = @parentType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_margin_15(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).margin;
        }

        static StackObject* CopyToStack_margin_15(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).margin;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_margin_15(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.margin = (global::Margin)v;
            o = ins;
        }

        static StackObject* AssignFromStack_margin_15(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            global::Margin @margin = (global::Margin)typeof(global::Margin).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.margin = @margin;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_eventType_16(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).eventType;
        }

        static StackObject* CopyToStack_eventType_16(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).eventType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_eventType_16(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.eventType = (huqiang.Core.UIData.HEventType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_eventType_16(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Core.UIData.HEventType @eventType = (huqiang.Core.UIData.HEventType)typeof(huqiang.Core.UIData.HEventType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.eventType = @eventType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_compositeType_17(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).compositeType;
        }

        static StackObject* CopyToStack_compositeType_17(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).compositeType;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_compositeType_17(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.compositeType = (huqiang.Core.UIData.CompositeType)v;
            o = ins;
        }

        static StackObject* AssignFromStack_compositeType_17(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Core.UIData.CompositeType @compositeType = (huqiang.Core.UIData.CompositeType)typeof(huqiang.Core.UIData.CompositeType).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)20);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.compositeType = @compositeType;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_child_18(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).child;
        }

        static StackObject* CopyToStack_child_18(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).child;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_child_18(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.child = (huqiang.Data.Int16ArrayPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_child_18(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.Int16ArrayPoint @child = (huqiang.Data.Int16ArrayPoint)typeof(huqiang.Data.Int16ArrayPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.child = @child;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_eve_19(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).eve;
        }

        static StackObject* CopyToStack_eve_19(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).eve;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_eve_19(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.eve = (huqiang.Data.FakeStrcutPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_eve_19(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.FakeStrcutPoint @eve = (huqiang.Data.FakeStrcutPoint)typeof(huqiang.Data.FakeStrcutPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.eve = @eve;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_composite_20(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).composite;
        }

        static StackObject* CopyToStack_composite_20(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).composite;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_composite_20(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.composite = (huqiang.Data.FakeStrcutPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_composite_20(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.FakeStrcutPoint @composite = (huqiang.Data.FakeStrcutPoint)typeof(huqiang.Data.FakeStrcutPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.composite = @composite;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_ex_21(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).ex;
        }

        static StackObject* CopyToStack_ex_21(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).ex;
            return ILIntepreter.PushObject(__ret, __mStack, result_of_this_method);
        }

        static void set_ex_21(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.ex = (huqiang.Data.FakeStrcutPoint)v;
            o = ins;
        }

        static StackObject* AssignFromStack_ex_21(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            huqiang.Data.FakeStrcutPoint @ex = (huqiang.Data.FakeStrcutPoint)typeof(huqiang.Data.FakeStrcutPoint).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack), (CLR.Utils.Extensions.TypeFlags)16);
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.ex = @ex;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_Mask_22(ref object o)
        {
            return ((huqiang.Core.UIData.UIElementData)o).Mask;
        }

        static StackObject* CopyToStack_Mask_22(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = ((huqiang.Core.UIData.UIElementData)o).Mask;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method ? 1 : 0;
            return __ret + 1;
        }

        static void set_Mask_22(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.Mask = (System.Boolean)v;
            o = ins;
        }

        static StackObject* AssignFromStack_Mask_22(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Boolean @Mask = ptr_of_this_method->Value == 1;
            huqiang.Core.UIData.UIElementData ins =(huqiang.Core.UIData.UIElementData)o;
            ins.Mask = @Mask;
            o = ins;
            return ptr_of_this_method;
        }

        static object get_Size_23(ref object o)
        {
            return huqiang.Core.UIData.UIElementData.Size;
        }

        static StackObject* CopyToStack_Size_23(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = huqiang.Core.UIData.UIElementData.Size;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_Size_23(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData.Size = (System.Int32)v;
        }

        static StackObject* AssignFromStack_Size_23(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @Size = ptr_of_this_method->Value;
            huqiang.Core.UIData.UIElementData.Size = @Size;
            return ptr_of_this_method;
        }

        static object get_ElementSize_24(ref object o)
        {
            return huqiang.Core.UIData.UIElementData.ElementSize;
        }

        static StackObject* CopyToStack_ElementSize_24(ref object o, ILIntepreter __intp, StackObject* __ret, IList<object> __mStack)
        {
            var result_of_this_method = huqiang.Core.UIData.UIElementData.ElementSize;
            __ret->ObjectType = ObjectTypes.Integer;
            __ret->Value = result_of_this_method;
            return __ret + 1;
        }

        static void set_ElementSize_24(ref object o, object v)
        {
            huqiang.Core.UIData.UIElementData.ElementSize = (System.Int32)v;
        }

        static StackObject* AssignFromStack_ElementSize_24(ref object o, ILIntepreter __intp, StackObject* ptr_of_this_method, IList<object> __mStack)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            System.Int32 @ElementSize = ptr_of_this_method->Value;
            huqiang.Core.UIData.UIElementData.ElementSize = @ElementSize;
            return ptr_of_this_method;
        }


        static object PerformMemberwiseClone(ref object o)
        {
            var ins = new huqiang.Core.UIData.UIElementData();
            ins = (huqiang.Core.UIData.UIElementData)o;
            return ins;
        }


    }
}
